{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 回归是如何变成分类的呢？\n",
    "\n",
    "之前在线性回归问题中，得到了具体的回归值，如果此时任务要做一个二分类该怎么办呢？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果可以将连续的数值转换成对应的区间，这样就可以完成分类任务了，逻辑回归中借助sigmoid函数完成了数值映射，通过概率值比较来完成分类任务"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import os\n",
    "%matplotlib inline\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "plt.rcParams['axes.labelsize'] = 14\n",
    "plt.rcParams['xtick.labelsize'] = 12\n",
    "plt.rcParams['ytick.labelsize'] = 12\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "np.random.seed(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 神奇的sigmoid函数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "t = np.linspace(-10, 10, 100)\n",
    "#【补充】linspace在这里是从-10到10，均匀生成100个数值\n",
    "#【实操】同学们可以在这里自己加入代码测试，比如print(np.linspace(-2, 2, 10))\n",
    "#【实操】后续代码也是，哪里不懂就print输出下，比如变量a的维度不懂，就print(a.shape)\n",
    "#【实操】也可以type查看数据的类型，比如是ndarray的，list的还是字典的\n",
    "#【练习】问1 [2] 上述变量t 都是什么格式或什么类型的数据？\n",
    "#【实操】print(type(1))     print(type([2]))    print(type(t)) \n",
    "\n",
    "\n",
    "sig = 1 / (1 + np.exp(-t))\n",
    "plt.figure(figsize=(9, 3))\n",
    "plt.plot([-10, 10], [0, 0], \"k-\")\n",
    "plt.plot([-10, 10], [0.5, 0.5], \"k:\")\n",
    "plt.plot([-10, 10], [1, 1], \"k:\")\n",
    "plt.plot([0, 0], [-1.1, 1.1], \"k-\")\n",
    "plt.plot(t, sig, \"b-\", linewidth=2, label=r\"$\\sigma(t) = \\frac{1}{1 + e^{-t}}$\")\n",
    "plt.xlabel(\"t\")\n",
    "plt.legend(loc=\"upper left\", fontsize=20)\n",
    "plt.axis([-10, 10, -0.1, 1.1])\n",
    "plt.title('Figure 4-21. Logistic function')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 推导公式：\n",
    "![title](./img6/1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 鸢尾花数据集：\n",
    "![title](./img6/2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 加载sklearn内置数据集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['data',\n",
       " 'target',\n",
       " 'frame',\n",
       " 'target_names',\n",
       " 'DESCR',\n",
       " 'feature_names',\n",
       " 'filename',\n",
       " 'data_module']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn import datasets\n",
    "# sklearn的datasets模块中很多的内置数据集：https://scikit-learn.org/stable/modules/classes.html#module-sklearn.datasets \n",
    "iris = datasets.load_iris() #加载数据\n",
    "#见：https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_iris.html#sklearn.datasets.load_iris\n",
    "#上述网页内有该数据集的详细说明，包含输入参数、输出、examples\n",
    "#可以看到输出的是：Dictionary-like object。即iris输出的总体是字典类型。\n",
    "list(iris.keys()) #用keys()可以查看有哪些属性可以调用。list()是把里面的内容转化成list格式\n",
    "#在显示的结果中，之前版本的没有frame和data_module属性。这些属性都可以直接调用。下面给出上述网页中的介绍\n",
    "# data：4个特征的数据；{ndarray, dataframe} of shape (150, 4)；The data matrix. If as_frame=True, data will be a pandas DataFrame.\n",
    "#target：标签（3种花）；{ndarray, Series} of shape (150,)；The classification target. If as_frame=True, target will be a pandas Series.\n",
    "#frame：数据和标签；DataFrame of shape (150, 5)；Only present when as_frame=True. DataFrame with data and target.\n",
    "#target_names：list格式；The names of target classes.\n",
    "#DESCR：描述；The full description of the dataset.\n",
    "#feature_names：特征的列名，list格式；The names of the dataset columns.\n",
    "#filename：str，即字符串格式；The path to the location of the data.\n",
    "#data_module：(data, target)tuple元组 if 输入参数return_X_y is True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".. _iris_dataset:\n",
      "\n",
      "Iris plants dataset\n",
      "--------------------\n",
      "\n",
      "**Data Set Characteristics:**\n",
      "\n",
      "    :Number of Instances: 150 (50 in each of three classes)\n",
      "    :Number of Attributes: 4 numeric, predictive attributes and the class\n",
      "    :Attribute Information:\n",
      "        - sepal length in cm\n",
      "        - sepal width in cm\n",
      "        - petal length in cm\n",
      "        - petal width in cm\n",
      "        - class:\n",
      "                - Iris-Setosa\n",
      "                - Iris-Versicolour\n",
      "                - Iris-Virginica\n",
      "                \n",
      "    :Summary Statistics:\n",
      "\n",
      "    ============== ==== ==== ======= ===== ====================\n",
      "                    Min  Max   Mean    SD   Class Correlation\n",
      "    ============== ==== ==== ======= ===== ====================\n",
      "    sepal length:   4.3  7.9   5.84   0.83    0.7826\n",
      "    sepal width:    2.0  4.4   3.05   0.43   -0.4194\n",
      "    petal length:   1.0  6.9   3.76   1.76    0.9490  (high!)\n",
      "    petal width:    0.1  2.5   1.20   0.76    0.9565  (high!)\n",
      "    ============== ==== ==== ======= ===== ====================\n",
      "\n",
      "    :Missing Attribute Values: None\n",
      "    :Class Distribution: 33.3% for each of 3 classes.\n",
      "    :Creator: R.A. Fisher\n",
      "    :Donor: Michael Marshall (MARSHALL%PLU@io.arc.nasa.gov)\n",
      "    :Date: July, 1988\n",
      "\n",
      "The famous Iris database, first used by Sir R.A. Fisher. The dataset is taken\n",
      "from Fisher's paper. Note that it's the same as in R, but not as in the UCI\n",
      "Machine Learning Repository, which has two wrong data points.\n",
      "\n",
      "This is perhaps the best known database to be found in the\n",
      "pattern recognition literature.  Fisher's paper is a classic in the field and\n",
      "is referenced frequently to this day.  (See Duda & Hart, for example.)  The\n",
      "data set contains 3 classes of 50 instances each, where each class refers to a\n",
      "type of iris plant.  One class is linearly separable from the other 2; the\n",
      "latter are NOT linearly separable from each other.\n",
      "\n",
      ".. topic:: References\n",
      "\n",
      "   - Fisher, R.A. \"The use of multiple measurements in taxonomic problems\"\n",
      "     Annual Eugenics, 7, Part II, 179-188 (1936); also in \"Contributions to\n",
      "     Mathematical Statistics\" (John Wiley, NY, 1950).\n",
      "   - Duda, R.O., & Hart, P.E. (1973) Pattern Classification and Scene Analysis.\n",
      "     (Q327.D83) John Wiley & Sons.  ISBN 0-471-22361-1.  See page 218.\n",
      "   - Dasarathy, B.V. (1980) \"Nosing Around the Neighborhood: A New System\n",
      "     Structure and Classification Rule for Recognition in Partially Exposed\n",
      "     Environments\".  IEEE Transactions on Pattern Analysis and Machine\n",
      "     Intelligence, Vol. PAMI-2, No. 1, 67-71.\n",
      "   - Gates, G.W. (1972) \"The Reduced Nearest Neighbor Rule\".  IEEE Transactions\n",
      "     on Information Theory, May 1972, 431-433.\n",
      "   - See also: 1988 MLC Proceedings, 54-64.  Cheeseman et al\"s AUTOCLASS II\n",
      "     conceptual clustering system finds 3 classes in the data.\n",
      "   - Many, many more ...\n"
     ]
    }
   ],
   "source": [
    "print (iris.DESCR) #DESCR：The full description of the dataset. 是load_iris的一个返回值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对于传统逻辑回归，要对标签做变换，也就是属于当前类别为1，其他类别为0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = iris['data'][:,3:] #因为iris是字典类似的数据，即其中ndarray格式的data是iris字典中的元素，按字典方式读取为iris['data']\n",
    "#[:,3:]：iris['data']是ndarray，这里只展示下第四个特征（花瓣的宽度）的列数据。可以print(X)或者直接键入X看一下。可以看到X是0到3之间的浮点数\n",
    "#学生的版本这里写的是第三个特征，写错了，因为python从0开始，0 1 2 3，所以是第四个特征。\n",
    "y = (iris['target'] == 2).astype(np.int) #实际的target有三个类别，这里归纳分为两个类别：是第2类别or不是第2类别。\n",
    "# (iris['target'] == 2)把是第2个类别的标签设置为True，不是第2类别的设置为False\n",
    "#.astype(np.int)把上述的True转化为1，False转化为0.\n",
    "\n",
    "#【实操】比如这里，你不知道X写的是什么，可以print(X)，输出下，看看结果\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression()"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression #加载sklearn下的逻辑回归方法\n",
    "#见：https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html#sklearn.linear_model.LogisticRegression\n",
    "log_res = LogisticRegression()#实例化\n",
    "#【补充】上面import是调用，在应用的时候需要实例化下，不能直接使用\n",
    "log_res.fit(X,y)#只有上述代表第4个特征的X作为一个特征，以是否是第2类花作为标签，进行二分类任务，用fit()训练模型参数。\n",
    "#学生的版本这里写的是第三个特征，写错了，因为python从0开始，0 1 2 3，所以是第四个特征。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_new = np.linspace(0,3,1000).reshape(-1,1)#因为上述我们已经展示了X属于0到3，所以做可视化展示，这里把0到3遍历1000个点，输出预测结果即可。\n",
    "# reshape的说明：https://blog.csdn.net/qq_29831163/article/details/90112000\n",
    "# 例：arr.shape #arr是a行b列的\n",
    "# arr,reshape(m,-1) #改变维度为m行d列，-1表示列数自动计算，d=a*b/m\n",
    "# arr,reshape(-1,m) #改变维度为d行m列，-1表示行数自动计算，d=a*b/m\n",
    "#所以这里reshape(-1,1)表示改变维度为d行1列，d=1*1000/1=1000 目的：当arr比较复杂时可以不用计算中间步骤，而可以得到想要的矩阵维度。\n",
    "y_proba = log_res.predict_proba(X_new)\n",
    "#在LogisticRegression包下有method的描述：predict()得到的是预测的分类标签；predict_proba()得到的是预测的概率值。\n",
    "#predict()默认是以概率0.5为界进行判断分类的，predict_proba()则是给出预测得到的概率值不做判断，要自己判断（比如你可以不设为0.5）.\n",
    "\n",
    "log_res.classes_ #由下述代码可以看到y_proba有两列，怎么判断哪列是属于当前类别的概率，哪列是不属于？这就需要看predict_proba的说明文档，\n",
    "#predict_proba(X)的返回值：the probability of the sample for each class in the model, where classes are ordered as they are in self.classes_.\n",
    "#也就是说要classes_，而在属性Attributes中可以看到可以直接调用classes_查看分类的排列顺序。\n",
    "#所以这里用log_res.classes_ 看到返回的是array([0, 1])，即第1列是不属于，第2列是属于。所以在y_proba中也沿用这个顺序。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[9.99250016e-01, 7.49984089e-04],\n",
       "       [9.99240201e-01, 7.59799387e-04],\n",
       "       [9.99230257e-01, 7.69743043e-04],\n",
       "       ...,\n",
       "       [3.08374822e-03, 9.96916252e-01],\n",
       "       [3.04400296e-03, 9.96955997e-01],\n",
       "       [3.00476842e-03, 9.96995232e-01]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_proba #1000个样本，所以这个概率y_proba是1000列，每一行有两个值，第一个是不属于当前类别的概率，第二个是属于当前类别的概率，两者求和为1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "随着输入特征数值的变化，结果概率值也会随之变化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1b9e63af100>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(12,5))#指定图像大小\n",
    "decision_boundary = X_new[y_proba[:,1]>=0.5][0]#绘制分类的交汇边界。因为一般是按照概率=0.5进行判断，所以用y_proba[:,1]>=0.5进行判断\n",
    "# X_new是一列数值，1000*1维数，比如y_proba[:,1]>=0.5的x_new有447个，则X_new[y_proba[:,1]>=0.5]返回的是447*1的矩阵，则X_new[y_proba[:,1]>=0.5][0]则是这个447*1维数矩阵的第一个数值。\n",
    "#【补充】y_proba[:,1]>=0.5在这里是提供了索引，用于调用哪些X_new中的元素。\n",
    "#【实操】print((X_new[y_proba[:,1]>=0.5]).shape) #可以看到返回的shape值是(447, 1)\n",
    "plt.plot([decision_boundary,decision_boundary],[-1,2],'k:',linewidth = 2) #以横轴为decision_boundary纵轴为-1；横轴为decision_boundary纵轴为2，为端点，绘制这两个点连线。\n",
    "plt.plot(X_new,y_proba[:,1],'g-',label = 'Iris-Virginica') #在y_proba中第2列是属于\n",
    "plt.plot(X_new,y_proba[:,0],'b--',label = 'Not Iris-Virginica') #在y_proba中第1列是不属于，#这样随着横轴即特征的变化，可以看到属于和不属于这两个标签的概率变化。\n",
    "plt.arrow(decision_boundary,0.08,-0.3,0,head_width = 0.05,head_length=0.1,fc='b',ec='b')#arrow是绘制箭头\n",
    "#由下述帮助文档可以查看arrow(x, y, dx, dy, **kwargs)，x和y是箭头的起点，dx, dy是x方向和y方向移动的距离。-0.3即沿着x的反方向走0.3，0是沿着y方向走0\n",
    "# head_width是箭头的宽度，head_length是箭头的长度,fc是箭头这个面的颜色，ec是箭头这个边缘的颜色。\n",
    "#目的：蓝色箭头表明随着x向左，不属于该分类的概率增加。\n",
    "plt.arrow(decision_boundary,0.92,0.3,0,head_width = 0.05,head_length=0.1,fc='g',ec='g')#与上述同理，绘制绿色箭头。\n",
    "plt.text(decision_boundary+0.02,0.15,'Decision Boundary',fontsize = 16,color = 'k',ha='center')#在图中加文字描述\n",
    "#字体在x轴的decision_boundary+0.02位置，y轴的0.15位置，加入文字'Decision Boundary'，字体尺寸16，颜色为黑色，布局在中间\n",
    "plt.xlabel('Peta width(cm)',fontsize = 16)#x轴名称，及字体的尺寸。\n",
    "plt.ylabel('y_proba',fontsize = 16)#y轴名称，及字体的尺寸。\n",
    "plt.axis([0,3,-0.02,1.02])#绘制x轴范围从0到3，y轴范围从-0.02到1.02\n",
    "plt.legend(loc = 'center left',fontsize = 16)#图例位置及字体的尺寸。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function arrow in module matplotlib.pyplot:\n",
      "\n",
      "arrow(x, y, dx, dy, **kwargs)\n",
      "    Add an arrow to the Axes.\n",
      "    \n",
      "    This draws an arrow from ``(x, y)`` to ``(x+dx, y+dy)``.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    x, y : float\n",
      "        The x and y coordinates of the arrow base.\n",
      "    \n",
      "    dx, dy : float\n",
      "        The length of the arrow along x and y direction.\n",
      "    \n",
      "    width : float, default: 0.001\n",
      "        Width of full arrow tail.\n",
      "    \n",
      "    length_includes_head : bool, default: False\n",
      "        True if head is to be counted in calculating the length.\n",
      "    \n",
      "    head_width : float or None, default: 3*width\n",
      "        Total width of the full arrow head.\n",
      "    \n",
      "    head_length : float or None, default: 1.5*head_width\n",
      "        Length of arrow head.\n",
      "    \n",
      "    shape : {'full', 'left', 'right'}, default: 'full'\n",
      "        Draw the left-half, right-half, or full arrow.\n",
      "    \n",
      "    overhang : float, default: 0\n",
      "        Fraction that the arrow is swept back (0 overhang means\n",
      "        triangular shape). Can be negative or greater than one.\n",
      "    \n",
      "    head_starts_at_zero : bool, default: False\n",
      "        If True, the head starts being drawn at coordinate 0\n",
      "        instead of ending at coordinate 0.\n",
      "    \n",
      "    **kwargs\n",
      "        `.Patch` properties:\n",
      "    \n",
      "        Properties:\n",
      "        agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "        alpha: unknown\n",
      "        animated: bool\n",
      "        antialiased or aa: bool or None\n",
      "        capstyle: `.CapStyle` or {'butt', 'projecting', 'round'}\n",
      "        clip_box: `.Bbox`\n",
      "        clip_on: bool\n",
      "        clip_path: Patch or (Path, Transform) or None\n",
      "        color: color\n",
      "        edgecolor or ec: color or None\n",
      "        facecolor or fc: color or None\n",
      "        figure: `.Figure`\n",
      "        fill: bool\n",
      "        gid: str\n",
      "        hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      "        in_layout: bool\n",
      "        joinstyle: `.JoinStyle` or {'miter', 'round', 'bevel'}\n",
      "        label: object\n",
      "        linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      "        linewidth or lw: float or None\n",
      "        path_effects: `.AbstractPathEffect`\n",
      "        picker: None or bool or float or callable\n",
      "        rasterized: bool\n",
      "        sketch_params: (scale: float, length: float, randomness: float)\n",
      "        snap: bool or None\n",
      "        transform: `.Transform`\n",
      "        url: str\n",
      "        visible: bool\n",
      "        zorder: float\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    `.FancyArrow`\n",
      "        The created `.FancyArrow` object.\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    The resulting arrow is affected by the Axes aspect ratio and limits.\n",
      "    This may produce an arrow whose head is not square with its stem. To\n",
      "    create an arrow whose head is square with its stem,\n",
      "    use :meth:`annotate` for example:\n",
      "    \n",
      "    >>> ax.annotate(\"\", xy=(0.5, 0.5), xytext=(0, 0),\n",
      "    ...             arrowprops=dict(arrowstyle=\"->\"))\n",
      "\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "print (help(plt.arrow))#比如箭头这个代码大家忘记怎么用了，可以用help指令查看帮助文档。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 从这里往下的内容是决策边界的绘制：\n",
    "X = iris['data'][:,(2,3)] #在样本中选择两个维度\n",
    "y = (iris['target']==2).astype(np.int) #与之前一样，属于类别2定义为数值1，不属于类别2的定义为数值0.\n",
    "\n",
    "#【补充】因为iris是字典类型，所以要用引号加载字典里的“关键词条” iris['data']\n",
    "#【补充】iris['data']下的第三列和第四列，即[:,(2,3)] \n",
    "#【练习】问：iris['data']的数据是什么格式？数据规模是什么？X长得什么样子？\n",
    "#【练习】答：print(iris['data'].shape)     print(type(iris['data']))  print(X)\n",
    "#【目的】大家以后遇到像X这种比较复杂的写法，可以逐步的print iris再'data'再[:,(2,3)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression(C=10000)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "log_res = LogisticRegression(C = 10000) #C参数在LogisticRegression类的官方说明中，写到它代表正则化的惩罚力度，是'inverse of regularization strength'，inverse是反向的含义，即正则化惩罚力度越大，C值越小，防止过拟合用的。\n",
    "#但C太小了也不好，会导致训练不准确，它的取值因不同数据而异，需要多次实验来确定（看看训练效果，由此调整C的取值）。在这里取C=1000，即正则化惩罚很小。（如果不加这个参数，默认C=1，则对于这个实验，惩罚力度过大了，训练处理的结果并不好，大家可以试着用C=1试一下。分类效果并不好）\n",
    "log_res.fit(X,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.0, 6.9)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X[:,0].min(),X[:,0].max()#查看第一个特征的min值和max值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.1, 2.5)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X[:,1].min(),X[:,1].max()#查看第二个特征的min值和max值。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 决策边界的绘制：\n",
    "- 构建坐标数据，合理的范围当中，根据实际训练时输入数据来决定\n",
    "- 整合坐标点，得到所有测试输入数据坐标点\n",
    "- 预测，得到所有点的概率值\n",
    "- 绘制等高线，完成决策边界"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "构建坐标数据："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "#这里举个小例子说明这句话的含义，后面会重新给x0，x1赋值\n",
    "x0,x1 = np.meshgrid(np.linspace(1,2,2).reshape(-1,1),np.linspace(10,20,3).reshape(-1,1))\n",
    "#np.linspace(1,2,2)代表x0从1到2选2个，即1和2；reshape(-1,1)再做成一个列向量(二维数组)。\n",
    "#np.linspace(10,20,3)代表x1从10到20选3个，即10，15和20；reshape(-1,1)再做成一个列向量(二维数组)。\n",
    "\n",
    "#meshgrid介绍：\n",
    "#X, Y = np.meshgrid(x, y)\n",
    "#假设 x, y 分别为 m, n 维向量，则矩阵（数组）X, Y 的 dimension 都是n*m的。其中矩阵 X 中的行都为向量 x，矩阵 Y 的列都为向量 y\n",
    "\n",
    "#参照上面介绍可以由下面代码查看x0和x1的取值，确实如上所述。\n",
    "#meshgrid()目的：用于生成网格采样点矩阵，之后用于画图。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 2.],\n",
       "       [1., 2.],\n",
       "       [1., 2.]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10., 10.],\n",
       "       [15., 15.],\n",
       "       [20., 20.]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1., 10.],\n",
       "       [ 2., 10.],\n",
       "       [ 1., 15.],\n",
       "       [ 2., 15.],\n",
       "       [ 1., 20.],\n",
       "       [ 2., 20.]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.c_[x0.ravel(),x1.ravel()] #把上述得到的采样点拼接成采用点矩阵。\n",
    "#x0.ravel()：把上述x0拉长，即得到array([1., 2., 1., 2., 1., 2.])   即一维数组\n",
    "#x1.ravel()：把上述x1拉长，即得到array([10., 10., 15., 15., 20., 20.])    即一维数组\n",
    "\n",
    "#[1,2]的shape值(2,)，意思是一维数组，数组中有2个元素\n",
    "#[[1],[2]]的shape值是(2,1)，意思是一个二维数组，每行有1个元素\n",
    "#[[1,2]]的shape值是（1，2），意思是一个二维数组，每行有2个元素\n",
    "#在numpy中，用二维数组（即矩阵），而不是一维数组来表示行向量和列向量：\n",
    "#因为Numpy中的数组shape为（m,）说明它是一个一维数组，或者说是一个向量，不区分列向量还是行向量，\n",
    "#一维数组在与矩阵进行矩阵乘法时，numpy会自动判断此时的一维数组应该取行向量还是列向量。\n",
    "\n",
    "#ravel() 和 flatten()都是拉长，numpy.flatten()返回一份拷贝，对拷贝所做的修改不会影响（reflects）原始矩阵，而numpy.ravel()返回的是视图，会影响（reflects）原始矩阵。\n",
    "#两者的区别见：https://blog.csdn.net/liuweiyuxiang/article/details/78220080\n",
    "\n",
    "# np.c_是按列进行拼接，此时x0.ravel(),x1.ravel()都是一维数组（不区分列向量还是行向量），这里理解为拼接的时候，按它们都是列向量。\n",
    "#即np.c_[x0.ravel(),x1.ravel()]的返回值是array([[ 1., 10.],[ 2., 10.],[ 1., 15.],[ 2., 15.],[ 1., 20.],[ 2., 20.]])，即二维数组，即6*2矩阵。\n",
    "\n",
    "#即x0,x1 = np.meshgrid(np.linspace(1,2,2).reshape(-1,1),np.linspace(10,20,3).reshape(-1,1))以及np.c_[x0.ravel(),x1.ravel()]这两句代码，\n",
    "#相当于得到了以x0为横轴，以x1为纵轴的网格。\n",
    "\n",
    "#【补充】目的是用坐标拉网格。绘制完网格，把p=0.5的网格点特殊标识，就是决策边界。\n",
    "#【实操】绘制一个x轴是2345，y轴是40 45 50的网格？\n",
    "#【答案】\n",
    "#x_tmp,y_tmp = np.meshgrid(np.linspace(2,5,4).reshape(-1,1),np.linspace(40,50,3).reshape(-1,1))\n",
    "#print(np.c_[x_tmp.ravel(),y_tmp.ravel()])\n",
    "#【补充】linspace(2,5,4)是2-5有4个点，即2 3 4 5；linspace(40,50,3)同理40 45 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "#通过上面的例子，这里为绘制决策边界继续写代码\n",
    "#上面得到x0从1.0到6.9，x1从0.1到2.5\n",
    "x0,x1 = np.meshgrid(np.linspace(2.9,7,500).reshape(-1,1),np.linspace(0.8,2.7,200).reshape(-1,1))\n",
    "# 这里为了绘图效果没完全按照x0从1.0到6.9，x1从0.1到2.5取网格点，而是x0从2.9到7，x1从0.8到2.7取网格点,大家也可自己修改,试试其他数组的效果。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2.9       , 0.8       ],\n",
       "       [2.90821643, 0.8       ],\n",
       "       [2.91643287, 0.8       ],\n",
       "       ...,\n",
       "       [6.98356713, 2.7       ],\n",
       "       [6.99178357, 2.7       ],\n",
       "       [7.        , 2.7       ]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_new = np.c_[x0.ravel(),x1.ravel()]#拼接在一期形成网格点，即测试用的样本，用于绘制决策边界。\n",
    "X_new"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(100000, 2)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_new.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_proba = log_res.predict_proba(X_new)#预测概率值，记得用实例化后的对象log_res，不要直接用类名LogisticRegression，否则报错。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(200, 500)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x0.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(200, 500)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(6.5, 2.3, 'Vir')"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10,4))\n",
    "plt.plot(X[y==0,0],X[y==0,1],'bs') #按不属于该分类绘制样本点X #X[y==0,0].shape返回(100,)，它是一维数组；而X是二维数组。X[y==0,0]把y是0的索引返回给X，取其第1列，返回一维数组。bs：b代表蓝色，s代表方块符合表示数据\n",
    "plt.plot(X[y==1,0],X[y==1,1],'g^') #按属于该分类绘制样本点X。g^：g代表绿色，^代表用三角形表示数据。\n",
    "\n",
    "zz = y_proba[:,1].reshape(x0.shape)# y_proba[:,1].shape是（100000，2）,即第1列是不属于该分类，第2列是属于该分类。把属于该分类的这100000个值按照.reshape(x0.shape)，即(200, 500)进行网格排列。由此zz，x0，x1的维度都保持一致了。\n",
    "#上句代码要用x0.shape不能用x0.shape()，否则报错：'tuple' object is not callable.\n",
    "#要是用zz = y_proba[:,0].reshape(x0.shape)则不属于该类别的等高线的数值大，大家可以自己操作下。\n",
    "contour = plt.contour(x0,x1,zz,cmap=plt.cm.brg)#plt.contour是matplotlib中绘制等高线的方法，plt.contour(横轴,纵轴,竖轴,颜色)\n",
    "plt.clabel(contour,inline = 1)#在等高线中添加数值，展示当前等高线是哪些数值的等高线。\n",
    "plt.axis([2.9,7,0.8,2.7])#展示图像中x轴取值范围是2.9到7，y轴范围是0.8到2.7\n",
    "plt.text(3.5,1.5,'NOT Vir',fontsize = 16,color = 'b')#在指定位置加文本注释\n",
    "plt.text(6.5,2.3,'Vir',fontsize = 16,color = 'g')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 如何进行多类别分类呢？Softmax该登场了"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](./img6/3.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = iris['data'][:,(2,3)] #样本有两个特征\n",
    "y = iris['target'] #target中有三个分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "#在tensorflow下交叉熵的计算见：https://zhuanlan.zhihu.com/p/105722023"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression(multi_class='multinomial')"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "softmax_reg = LogisticRegression(multi_class = 'multinomial',solver='lbfgs') ##multi_class = 'multinomialhttps://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html：指定为多分类问题，solver='lbfgs'指定求解器\n",
    "# 上述内容在：https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html#sklearn.linear_model.LogisticRegression 都有说明\n",
    "softmax_reg.fit(X,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "softmax_reg.predict([[5,2]]) #设定样本下两个特征为5和2，预测下该样本属于哪个分类。 可以看到返回array([2])，即属于第三个分类。三个分类分别是：0，1，2。即2是第三个分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2.43559894e-04, 2.14859516e-01, 7.84896924e-01]])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "softmax_reg.predict_proba([[5,2]]) #设定样本下两个特征为5和2，预测下该样本属于这三个分类的概率值。即完成多分类任务的求解。\n",
    "#返回array([[2.43559894e-04, 2.14859516e-01, 7.84896924e-01]])，即第三个分类的概率最大，所以属于第3个分类。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x0, x1 = np.meshgrid(\n",
    "        np.linspace(0, 8, 500).reshape(-1, 1),\n",
    "        np.linspace(0, 3.5, 200).reshape(-1, 1),\n",
    "    )\n",
    "X_new = np.c_[x0.ravel(), x1.ravel()]\n",
    "\n",
    "#与上述代码一致，绘制等高线\n",
    "y_proba = softmax_reg.predict_proba(X_new)\n",
    "y_predict = softmax_reg.predict(X_new)\n",
    "\n",
    "zz1 = y_proba[:, 1].reshape(x0.shape)\n",
    "zz = y_predict.reshape(x0.shape)\n",
    "\n",
    "plt.figure(figsize=(10, 4))\n",
    "plt.plot(X[y==2, 0], X[y==2, 1], \"g^\", label=\"Iris-Virginica\")\n",
    "plt.plot(X[y==1, 0], X[y==1, 1], \"bs\", label=\"Iris-Versicolor\")\n",
    "plt.plot(X[y==0, 0], X[y==0, 1], \"yo\", label=\"Iris-Setosa\")\n",
    "\n",
    "from matplotlib.colors import ListedColormap\n",
    "custom_cmap = ListedColormap(['#fafab0','#9898ff','#a0faa0'])\n",
    "\n",
    "plt.contourf(x0, x1, zz, cmap=custom_cmap)\n",
    "contour = plt.contour(x0, x1, zz1, cmap=plt.cm.brg) #以上述zz1绘制等高线的概率，上述zz1用的是第二个分类概率；\n",
    "#大家可以通过修改zz1来按照第1个分类或第3个分类绘制等高线。比如之前代码改为zz1 = y_proba[:, 2].reshape(x0.shape)即按第3个分类绘制等高线。\n",
    "plt.clabel(contour, inline=1, fontsize=12)\n",
    "plt.xlabel(\"Petal length\", fontsize=14)\n",
    "plt.ylabel(\"Petal width\", fontsize=14)\n",
    "plt.legend(loc=\"center left\", fontsize=14)\n",
    "plt.axis([0, 7, 0, 3.5])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "#【补充】：给大家留时间回顾下，看看有什么问题？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "思考题："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1sigmoid函数的公式是什么？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2逻辑回归的决策边界可以是非线性的吗？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3sigmoid函数的定义域和值域是什么？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4逻辑回归是如何借助sigmoid函数完成分类任务的？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5用于求解多分类问题的softmax函数形式？用于衡量损失的交叉熵怎么写？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6你有样本量是1万的标签，如何快速实现查看标签的所有分类?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7对于分类问题，当你不确定标签是字符型的还是数值型的，如何为标签事先定义一个数组，用于存储标签？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8如何在sklearn库中载入逻辑回归方法，并实现实例化、训练模型、预测新样本的标签及概率？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9在逻辑回归实例化过程中，如何加入代表正则项的参数，该参数的取值大小与惩罚力度的关系是什么？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "10 X是a行b列的矩阵。下面代码是什么意思。\n",
    "\n",
    "X.reshape(m,-1)\n",
    "X.reshape(-1,m) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "11如何生成网格（棋盘）数据？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "12如何利用LogisticRegression函数完成多分类逻辑回归任务？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "13当你需要求解优化问题时，会用minimize求解优化问题吗？\n",
    "比如：\n",
    "\n",
    "result = minimize(\n",
    "lambda current_theta:LogisticRegression.cost_function(data,labels,current_theta.reshape(num_features,1)), current_initial_theta, method = 'CG', \n",
    "    jac = lambda current_theta:LogisticRegression.gradient_step(data,labels,current_theta.reshape(num_features,1)),\n",
    "    callback=lambda current_theta:cost_history.append(LogisticRegression.cost_function(data,labels,current_theta.reshape((num_features,1)))),\n",
    "    options={'maxiter': max_iterations})\n",
    "\n",
    "可以说明这里的参数对应着优化问题的什么元素吗?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "14逻辑回归分类的精度不够高，因此在业界很少用到这个算法 \n",
    "A.正确\n",
    "B.错误\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "15Logistic回归适用于因变量为 \n",
    "A.二分类变量   B.多分类变量   C.连续型变量   D. A、B均可\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "16假设你训练了一个逻辑回归分类器，对于一个新样本x，得到hθ(x)=0.2.这意味着：\n",
    "A.P(y=1|x;θ)=0.2   B.P(y=1|x;θ)=0.8   C.P(y=0|x;θ)=0.8   D.P(y=0|x;θ)=0.2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "17 多选题"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](./img6/ti4.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "18 单选题"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](./img6/ti51.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](./img6/ti52.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](./img6/ti53.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](./img6/ti54.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "19单选题"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](./img6/ti6.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "20单选题"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](./img6/ti7.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.0rc2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
